As processors evolve and/or new processor families/architectures emerge, existing software programs may not be efficiently executable/run on these new processors. These problems arise due to lack of binary compatibility between new processor families/architectures and/or older processors. This is because computers may naturally execute programs coded in their own native instruction set architecture (ISA), the ISA of the architecture family for which the computer is a member. In other words, as processors evolve, their instruction sets may change and/or prevent existing software programs from being executed on the new processors unless some action is taken. Authors of software programs may either rewrite and/or recompile their software programs and/or processor manufacturers may provide instructions to replicate previous instructions. Both of these solutions may have their drawbacks as either it may require users to purchase a new version to use with a new machine which may cause the existing users to incur additional costs of redeployment and/or re-certification, or can require including instructions into newer processors to replicate previous instructions. This may limit advances that may be made to the new processor due to cost and limitations of the legacy instructions and architecture. Therefore, transitioning to a new architecture may never be easy. Users may want to keep running their favorite applications as they normally would, without stopping to adapt them to a different platform. For some legacy applications the problem may be more severe. Without all the source code, it may be impossible to recompile the applications to a new platform. Thus, porting these legacy applications may require a method for forming profiling information of one computer platform in another computer platform which can result in not being just slow but may be impossible too.
Dynamic binary translators (DBTs) may provide a possible solution to these issues. A DBT may dynamically translate all or a portion of source program (e.g., a program understandable by one processor family) into an associated target program (e.g., a program understandable by another processor family) on a target machine during execution. This translation may allow a user to execute programs that the user previously may have used on an older machine, on a new machine without having to create a new version of the software, and/or may allow the processor to abandon some or all legacy instructions and/or architecture features. Basically, DBTs may translate the binary code from one instruction set to another without the need for high-level source code.
However, using DBTs to translate the binary code from one instruction set to another may result in performance issues due to difference in system behavior, such as cache latency, spin lock performance and the like on the new platform. Generally, applications have performance monitoring tools that may detect these problem areas, but such tools may be rarely supported on the new platform. This generally results in monitoring and/or measuring the emulator performance and not the emulated application due to non-availability of instrumented code in the released production version of the application software. This may result in masking the reasons for the sub-optimal performance of the emulated applications. Further, non-native execution may be slower than native execution as a non-native program may incur translation and/or book-keeping overheads.
Other features of the present embodiments will be apparent from the accompanying drawings and from the detailed description that follows.